// $ANTLR 3.2 Sep 23, 2009 12:02:23 D:\\workspace\\TBT-front-end\\grammar\\TBTLexer.g 2010-07-13 11:28:54

  package parser;


import org.antlr.runtime.*;
import java.util.Stack;
import java.util.List;
import java.util.ArrayList;

public class TBTLexer extends Lexer {
    public static final int STAR=17;
    public static final int CASE=20;
    public static final int FORALL=7;
    public static final int LCURLY=26;
    public static final int DEDENT=6;
    public static final int ID=31;
    public static final int OF=21;
    public static final int EOF=-1;
    public static final int SEMI=12;
    public static final int LPAREN=24;
    public static final int INDENT=5;
    public static final int TLAMBDA=9;
    public static final int RPAREN=25;
    public static final int IND=22;
    public static final int LETREC=18;
    public static final int WS=33;
    public static final int RANG=29;
    public static final int BIND=14;
    public static final int RCURLY=27;
    public static final int OR=15;
    public static final int COLUMN=30;
    public static final int ARROW=8;
    public static final int DARROW=16;
    public static final int TID=32;
    public static final int LAMBDA=10;
    public static final int EQ=13;
    public static final int COMMENT=34;
    public static final int DOT=11;
    public static final int COIND=23;
    public static final int SPATIU=4;
    public static final int LET=19;
    public static final int LANG=28;

      int open = 0;


    // delegates
    // delegators

    public TBTLexer() {;} 
    public TBTLexer(CharStream input) {
        this(input, new RecognizerSharedState());
    }
    public TBTLexer(CharStream input, RecognizerSharedState state) {
        super(input,state);

    }
    public String getGrammarFileName() { return "D:\\workspace\\TBT-front-end\\grammar\\TBTLexer.g"; }

    // $ANTLR start "FORALL"
    public final void mFORALL() throws RecognitionException {
        try {
            int _type = FORALL;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // D:\\workspace\\TBT-front-end\\grammar\\TBTLexer.g:19:9: ( '\\\\/' )
            // D:\\workspace\\TBT-front-end\\grammar\\TBTLexer.g:19:11: '\\\\/'
            {
            match("\\/"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "FORALL"

    // $ANTLR start "ARROW"
    public final void mARROW() throws RecognitionException {
        try {
            int _type = ARROW;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // D:\\workspace\\TBT-front-end\\grammar\\TBTLexer.g:20:9: ( '->' )
            // D:\\workspace\\TBT-front-end\\grammar\\TBTLexer.g:20:11: '->'
            {
            match("->"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "ARROW"

    // $ANTLR start "TLAMBDA"
    public final void mTLAMBDA() throws RecognitionException {
        try {
            int _type = TLAMBDA;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // D:\\workspace\\TBT-front-end\\grammar\\TBTLexer.g:21:9: ( '/\\\\' )
            // D:\\workspace\\TBT-front-end\\grammar\\TBTLexer.g:21:11: '/\\\\'
            {
            match("/\\"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "TLAMBDA"

    // $ANTLR start "LAMBDA"
    public final void mLAMBDA() throws RecognitionException {
        try {
            int _type = LAMBDA;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // D:\\workspace\\TBT-front-end\\grammar\\TBTLexer.g:22:9: ( 'fn' )
            // D:\\workspace\\TBT-front-end\\grammar\\TBTLexer.g:22:11: 'fn'
            {
            match("fn"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "LAMBDA"

    // $ANTLR start "DOT"
    public final void mDOT() throws RecognitionException {
        try {
            int _type = DOT;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // D:\\workspace\\TBT-front-end\\grammar\\TBTLexer.g:23:9: ( '.' )
            // D:\\workspace\\TBT-front-end\\grammar\\TBTLexer.g:23:11: '.'
            {
            match('.'); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "DOT"

    // $ANTLR start "SEMI"
    public final void mSEMI() throws RecognitionException {
        try {
            int _type = SEMI;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // D:\\workspace\\TBT-front-end\\grammar\\TBTLexer.g:24:9: ( ':' )
            // D:\\workspace\\TBT-front-end\\grammar\\TBTLexer.g:24:11: ':'
            {
            match(':'); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "SEMI"

    // $ANTLR start "EQ"
    public final void mEQ() throws RecognitionException {
        try {
            int _type = EQ;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // D:\\workspace\\TBT-front-end\\grammar\\TBTLexer.g:25:9: ( '=' )
            // D:\\workspace\\TBT-front-end\\grammar\\TBTLexer.g:25:11: '='
            {
            match('='); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "EQ"

    // $ANTLR start "BIND"
    public final void mBIND() throws RecognitionException {
        try {
            int _type = BIND;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // D:\\workspace\\TBT-front-end\\grammar\\TBTLexer.g:26:9: ( ':=' )
            // D:\\workspace\\TBT-front-end\\grammar\\TBTLexer.g:26:11: ':='
            {
            match(":="); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "BIND"

    // $ANTLR start "OR"
    public final void mOR() throws RecognitionException {
        try {
            int _type = OR;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // D:\\workspace\\TBT-front-end\\grammar\\TBTLexer.g:27:9: ( '|' )
            // D:\\workspace\\TBT-front-end\\grammar\\TBTLexer.g:27:11: '|'
            {
            match('|'); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "OR"

    // $ANTLR start "DARROW"
    public final void mDARROW() throws RecognitionException {
        try {
            int _type = DARROW;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // D:\\workspace\\TBT-front-end\\grammar\\TBTLexer.g:28:9: ( '=>' )
            // D:\\workspace\\TBT-front-end\\grammar\\TBTLexer.g:28:11: '=>'
            {
            match("=>"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "DARROW"

    // $ANTLR start "STAR"
    public final void mSTAR() throws RecognitionException {
        try {
            int _type = STAR;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // D:\\workspace\\TBT-front-end\\grammar\\TBTLexer.g:29:9: ( '*' )
            // D:\\workspace\\TBT-front-end\\grammar\\TBTLexer.g:29:11: '*'
            {
            match('*'); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "STAR"

    // $ANTLR start "LETREC"
    public final void mLETREC() throws RecognitionException {
        try {
            int _type = LETREC;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // D:\\workspace\\TBT-front-end\\grammar\\TBTLexer.g:31:9: ( 'letrec' )
            // D:\\workspace\\TBT-front-end\\grammar\\TBTLexer.g:31:11: 'letrec'
            {
            match("letrec"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "LETREC"

    // $ANTLR start "LET"
    public final void mLET() throws RecognitionException {
        try {
            int _type = LET;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // D:\\workspace\\TBT-front-end\\grammar\\TBTLexer.g:32:9: ( 'let' )
            // D:\\workspace\\TBT-front-end\\grammar\\TBTLexer.g:32:11: 'let'
            {
            match("let"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "LET"

    // $ANTLR start "CASE"
    public final void mCASE() throws RecognitionException {
        try {
            int _type = CASE;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // D:\\workspace\\TBT-front-end\\grammar\\TBTLexer.g:33:9: ( 'case' )
            // D:\\workspace\\TBT-front-end\\grammar\\TBTLexer.g:33:11: 'case'
            {
            match("case"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "CASE"

    // $ANTLR start "OF"
    public final void mOF() throws RecognitionException {
        try {
            int _type = OF;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // D:\\workspace\\TBT-front-end\\grammar\\TBTLexer.g:34:9: ( 'of' )
            // D:\\workspace\\TBT-front-end\\grammar\\TBTLexer.g:34:11: 'of'
            {
            match("of"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "OF"

    // $ANTLR start "IND"
    public final void mIND() throws RecognitionException {
        try {
            int _type = IND;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // D:\\workspace\\TBT-front-end\\grammar\\TBTLexer.g:35:9: ( 'Inductive' )
            // D:\\workspace\\TBT-front-end\\grammar\\TBTLexer.g:35:11: 'Inductive'
            {
            match("Inductive"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "IND"

    // $ANTLR start "COIND"
    public final void mCOIND() throws RecognitionException {
        try {
            int _type = COIND;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // D:\\workspace\\TBT-front-end\\grammar\\TBTLexer.g:36:9: ( 'Coinductive' )
            // D:\\workspace\\TBT-front-end\\grammar\\TBTLexer.g:36:11: 'Coinductive'
            {
            match("Coinductive"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "COIND"

    // $ANTLR start "LPAREN"
    public final void mLPAREN() throws RecognitionException {
        try {
            int _type = LPAREN;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // D:\\workspace\\TBT-front-end\\grammar\\TBTLexer.g:38:9: ( '(' )
            // D:\\workspace\\TBT-front-end\\grammar\\TBTLexer.g:38:11: '('
            {
            match('('); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "LPAREN"

    // $ANTLR start "RPAREN"
    public final void mRPAREN() throws RecognitionException {
        try {
            int _type = RPAREN;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // D:\\workspace\\TBT-front-end\\grammar\\TBTLexer.g:39:9: ( ')' )
            // D:\\workspace\\TBT-front-end\\grammar\\TBTLexer.g:39:11: ')'
            {
            match(')'); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "RPAREN"

    // $ANTLR start "LCURLY"
    public final void mLCURLY() throws RecognitionException {
        try {
            int _type = LCURLY;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // D:\\workspace\\TBT-front-end\\grammar\\TBTLexer.g:41:9: ( '{' )
            // D:\\workspace\\TBT-front-end\\grammar\\TBTLexer.g:41:11: '{'
            {
            match('{'); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "LCURLY"

    // $ANTLR start "RCURLY"
    public final void mRCURLY() throws RecognitionException {
        try {
            int _type = RCURLY;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // D:\\workspace\\TBT-front-end\\grammar\\TBTLexer.g:42:9: ( '}' )
            // D:\\workspace\\TBT-front-end\\grammar\\TBTLexer.g:42:11: '}'
            {
            match('}'); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "RCURLY"

    // $ANTLR start "LANG"
    public final void mLANG() throws RecognitionException {
        try {
            int _type = LANG;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // D:\\workspace\\TBT-front-end\\grammar\\TBTLexer.g:44:9: ( '<' )
            // D:\\workspace\\TBT-front-end\\grammar\\TBTLexer.g:44:11: '<'
            {
            match('<'); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "LANG"

    // $ANTLR start "RANG"
    public final void mRANG() throws RecognitionException {
        try {
            int _type = RANG;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // D:\\workspace\\TBT-front-end\\grammar\\TBTLexer.g:45:9: ( '>' )
            // D:\\workspace\\TBT-front-end\\grammar\\TBTLexer.g:45:11: '>'
            {
            match('>'); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "RANG"

    // $ANTLR start "COLUMN"
    public final void mCOLUMN() throws RecognitionException {
        try {
            int _type = COLUMN;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // D:\\workspace\\TBT-front-end\\grammar\\TBTLexer.g:47:9: ( ';' )
            // D:\\workspace\\TBT-front-end\\grammar\\TBTLexer.g:47:11: ';'
            {
            match(';'); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "COLUMN"

    // $ANTLR start "ID"
    public final void mID() throws RecognitionException {
        try {
            int _type = ID;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // D:\\workspace\\TBT-front-end\\grammar\\TBTLexer.g:49:5: ( ( 'a' .. 'z' | '0' .. '9' ) ( 'a' .. 'z' | 'A' .. 'Z' | '0' .. '9' | '_' )* | '\\\\' . )
            int alt2=2;
            int LA2_0 = input.LA(1);

            if ( ((LA2_0>='0' && LA2_0<='9')||(LA2_0>='a' && LA2_0<='z')) ) {
                alt2=1;
            }
            else if ( (LA2_0=='\\') ) {
                alt2=2;
            }
            else {
                NoViableAltException nvae =
                    new NoViableAltException("", 2, 0, input);

                throw nvae;
            }
            switch (alt2) {
                case 1 :
                    // D:\\workspace\\TBT-front-end\\grammar\\TBTLexer.g:49:7: ( 'a' .. 'z' | '0' .. '9' ) ( 'a' .. 'z' | 'A' .. 'Z' | '0' .. '9' | '_' )*
                    {
                    if ( (input.LA(1)>='0' && input.LA(1)<='9')||(input.LA(1)>='a' && input.LA(1)<='z') ) {
                        input.consume();

                    }
                    else {
                        MismatchedSetException mse = new MismatchedSetException(null,input);
                        recover(mse);
                        throw mse;}

                    // D:\\workspace\\TBT-front-end\\grammar\\TBTLexer.g:49:26: ( 'a' .. 'z' | 'A' .. 'Z' | '0' .. '9' | '_' )*
                    loop1:
                    do {
                        int alt1=2;
                        int LA1_0 = input.LA(1);

                        if ( ((LA1_0>='0' && LA1_0<='9')||(LA1_0>='A' && LA1_0<='Z')||LA1_0=='_'||(LA1_0>='a' && LA1_0<='z')) ) {
                            alt1=1;
                        }


                        switch (alt1) {
                    	case 1 :
                    	    // D:\\workspace\\TBT-front-end\\grammar\\TBTLexer.g:
                    	    {
                    	    if ( (input.LA(1)>='0' && input.LA(1)<='9')||(input.LA(1)>='A' && input.LA(1)<='Z')||input.LA(1)=='_'||(input.LA(1)>='a' && input.LA(1)<='z') ) {
                    	        input.consume();

                    	    }
                    	    else {
                    	        MismatchedSetException mse = new MismatchedSetException(null,input);
                    	        recover(mse);
                    	        throw mse;}


                    	    }
                    	    break;

                    	default :
                    	    break loop1;
                        }
                    } while (true);


                    }
                    break;
                case 2 :
                    // D:\\workspace\\TBT-front-end\\grammar\\TBTLexer.g:49:62: '\\\\' .
                    {
                    match('\\'); 
                    matchAny(); 

                    }
                    break;

            }
            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "ID"

    // $ANTLR start "TID"
    public final void mTID() throws RecognitionException {
        try {
            int _type = TID;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // D:\\workspace\\TBT-front-end\\grammar\\TBTLexer.g:52:5: ( ( 'A' .. 'Z' ) ( 'a' .. 'z' | 'A' .. 'Z' | '0' .. '9' | '_' )* )
            // D:\\workspace\\TBT-front-end\\grammar\\TBTLexer.g:52:7: ( 'A' .. 'Z' ) ( 'a' .. 'z' | 'A' .. 'Z' | '0' .. '9' | '_' )*
            {
            // D:\\workspace\\TBT-front-end\\grammar\\TBTLexer.g:52:7: ( 'A' .. 'Z' )
            // D:\\workspace\\TBT-front-end\\grammar\\TBTLexer.g:52:8: 'A' .. 'Z'
            {
            matchRange('A','Z'); 

            }

            // D:\\workspace\\TBT-front-end\\grammar\\TBTLexer.g:52:18: ( 'a' .. 'z' | 'A' .. 'Z' | '0' .. '9' | '_' )*
            loop3:
            do {
                int alt3=2;
                int LA3_0 = input.LA(1);

                if ( ((LA3_0>='0' && LA3_0<='9')||(LA3_0>='A' && LA3_0<='Z')||LA3_0=='_'||(LA3_0>='a' && LA3_0<='z')) ) {
                    alt3=1;
                }


                switch (alt3) {
            	case 1 :
            	    // D:\\workspace\\TBT-front-end\\grammar\\TBTLexer.g:
            	    {
            	    if ( (input.LA(1)>='0' && input.LA(1)<='9')||(input.LA(1)>='A' && input.LA(1)<='Z')||input.LA(1)=='_'||(input.LA(1)>='a' && input.LA(1)<='z') ) {
            	        input.consume();

            	    }
            	    else {
            	        MismatchedSetException mse = new MismatchedSetException(null,input);
            	        recover(mse);
            	        throw mse;}


            	    }
            	    break;

            	default :
            	    break loop3;
                }
            } while (true);


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "TID"

    // $ANTLR start "WS"
    public final void mWS() throws RecognitionException {
        try {
            int _type = WS;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // D:\\workspace\\TBT-front-end\\grammar\\TBTLexer.g:57:5: ( ( ' ' | '\\t' | '\\n' | '\\r' )+ )
            // D:\\workspace\\TBT-front-end\\grammar\\TBTLexer.g:57:9: ( ' ' | '\\t' | '\\n' | '\\r' )+
            {
            // D:\\workspace\\TBT-front-end\\grammar\\TBTLexer.g:57:9: ( ' ' | '\\t' | '\\n' | '\\r' )+
            int cnt4=0;
            loop4:
            do {
                int alt4=2;
                int LA4_0 = input.LA(1);

                if ( ((LA4_0>='\t' && LA4_0<='\n')||LA4_0=='\r'||LA4_0==' ') ) {
                    alt4=1;
                }


                switch (alt4) {
            	case 1 :
            	    // D:\\workspace\\TBT-front-end\\grammar\\TBTLexer.g:
            	    {
            	    if ( (input.LA(1)>='\t' && input.LA(1)<='\n')||input.LA(1)=='\r'||input.LA(1)==' ' ) {
            	        input.consume();

            	    }
            	    else {
            	        MismatchedSetException mse = new MismatchedSetException(null,input);
            	        recover(mse);
            	        throw mse;}


            	    }
            	    break;

            	default :
            	    if ( cnt4 >= 1 ) break loop4;
                        EarlyExitException eee =
                            new EarlyExitException(4, input);
                        throw eee;
                }
                cnt4++;
            } while (true);

             skip();

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "WS"

    // $ANTLR start "COMMENT"
    public final void mCOMMENT() throws RecognitionException {
        try {
            int _type = COMMENT;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // D:\\workspace\\TBT-front-end\\grammar\\TBTLexer.g:61:5: ( '#' (~ ( '\\n' | '\\r' ) )* | '---' (~ ( '\\n' | '\\r' ) )* | '//' (~ ( '\\n' | '\\r' ) )* | '(*' ( options {greedy=false; } : . )* '*)' )
            int alt9=4;
            switch ( input.LA(1) ) {
            case '#':
                {
                alt9=1;
                }
                break;
            case '-':
                {
                alt9=2;
                }
                break;
            case '/':
                {
                alt9=3;
                }
                break;
            case '(':
                {
                alt9=4;
                }
                break;
            default:
                NoViableAltException nvae =
                    new NoViableAltException("", 9, 0, input);

                throw nvae;
            }

            switch (alt9) {
                case 1 :
                    // D:\\workspace\\TBT-front-end\\grammar\\TBTLexer.g:61:9: '#' (~ ( '\\n' | '\\r' ) )*
                    {
                    match('#'); 
                    // D:\\workspace\\TBT-front-end\\grammar\\TBTLexer.g:61:13: (~ ( '\\n' | '\\r' ) )*
                    loop5:
                    do {
                        int alt5=2;
                        int LA5_0 = input.LA(1);

                        if ( ((LA5_0>='\u0000' && LA5_0<='\t')||(LA5_0>='\u000B' && LA5_0<='\f')||(LA5_0>='\u000E' && LA5_0<='\uFFFF')) ) {
                            alt5=1;
                        }


                        switch (alt5) {
                    	case 1 :
                    	    // D:\\workspace\\TBT-front-end\\grammar\\TBTLexer.g:61:13: ~ ( '\\n' | '\\r' )
                    	    {
                    	    if ( (input.LA(1)>='\u0000' && input.LA(1)<='\t')||(input.LA(1)>='\u000B' && input.LA(1)<='\f')||(input.LA(1)>='\u000E' && input.LA(1)<='\uFFFF') ) {
                    	        input.consume();

                    	    }
                    	    else {
                    	        MismatchedSetException mse = new MismatchedSetException(null,input);
                    	        recover(mse);
                    	        throw mse;}


                    	    }
                    	    break;

                    	default :
                    	    break loop5;
                        }
                    } while (true);

                    skip();

                    }
                    break;
                case 2 :
                    // D:\\workspace\\TBT-front-end\\grammar\\TBTLexer.g:62:9: '---' (~ ( '\\n' | '\\r' ) )*
                    {
                    match("---"); 

                    // D:\\workspace\\TBT-front-end\\grammar\\TBTLexer.g:62:15: (~ ( '\\n' | '\\r' ) )*
                    loop6:
                    do {
                        int alt6=2;
                        int LA6_0 = input.LA(1);

                        if ( ((LA6_0>='\u0000' && LA6_0<='\t')||(LA6_0>='\u000B' && LA6_0<='\f')||(LA6_0>='\u000E' && LA6_0<='\uFFFF')) ) {
                            alt6=1;
                        }


                        switch (alt6) {
                    	case 1 :
                    	    // D:\\workspace\\TBT-front-end\\grammar\\TBTLexer.g:62:15: ~ ( '\\n' | '\\r' )
                    	    {
                    	    if ( (input.LA(1)>='\u0000' && input.LA(1)<='\t')||(input.LA(1)>='\u000B' && input.LA(1)<='\f')||(input.LA(1)>='\u000E' && input.LA(1)<='\uFFFF') ) {
                    	        input.consume();

                    	    }
                    	    else {
                    	        MismatchedSetException mse = new MismatchedSetException(null,input);
                    	        recover(mse);
                    	        throw mse;}


                    	    }
                    	    break;

                    	default :
                    	    break loop6;
                        }
                    } while (true);

                    skip();

                    }
                    break;
                case 3 :
                    // D:\\workspace\\TBT-front-end\\grammar\\TBTLexer.g:63:9: '//' (~ ( '\\n' | '\\r' ) )*
                    {
                    match("//"); 

                    // D:\\workspace\\TBT-front-end\\grammar\\TBTLexer.g:63:14: (~ ( '\\n' | '\\r' ) )*
                    loop7:
                    do {
                        int alt7=2;
                        int LA7_0 = input.LA(1);

                        if ( ((LA7_0>='\u0000' && LA7_0<='\t')||(LA7_0>='\u000B' && LA7_0<='\f')||(LA7_0>='\u000E' && LA7_0<='\uFFFF')) ) {
                            alt7=1;
                        }


                        switch (alt7) {
                    	case 1 :
                    	    // D:\\workspace\\TBT-front-end\\grammar\\TBTLexer.g:63:14: ~ ( '\\n' | '\\r' )
                    	    {
                    	    if ( (input.LA(1)>='\u0000' && input.LA(1)<='\t')||(input.LA(1)>='\u000B' && input.LA(1)<='\f')||(input.LA(1)>='\u000E' && input.LA(1)<='\uFFFF') ) {
                    	        input.consume();

                    	    }
                    	    else {
                    	        MismatchedSetException mse = new MismatchedSetException(null,input);
                    	        recover(mse);
                    	        throw mse;}


                    	    }
                    	    break;

                    	default :
                    	    break loop7;
                        }
                    } while (true);

                    skip();

                    }
                    break;
                case 4 :
                    // D:\\workspace\\TBT-front-end\\grammar\\TBTLexer.g:64:9: '(*' ( options {greedy=false; } : . )* '*)'
                    {
                    match("(*"); 

                    // D:\\workspace\\TBT-front-end\\grammar\\TBTLexer.g:64:14: ( options {greedy=false; } : . )*
                    loop8:
                    do {
                        int alt8=2;
                        int LA8_0 = input.LA(1);

                        if ( (LA8_0=='*') ) {
                            int LA8_1 = input.LA(2);

                            if ( (LA8_1==')') ) {
                                alt8=2;
                            }
                            else if ( ((LA8_1>='\u0000' && LA8_1<='(')||(LA8_1>='*' && LA8_1<='\uFFFF')) ) {
                                alt8=1;
                            }


                        }
                        else if ( ((LA8_0>='\u0000' && LA8_0<=')')||(LA8_0>='+' && LA8_0<='\uFFFF')) ) {
                            alt8=1;
                        }


                        switch (alt8) {
                    	case 1 :
                    	    // D:\\workspace\\TBT-front-end\\grammar\\TBTLexer.g:64:41: .
                    	    {
                    	    matchAny(); 

                    	    }
                    	    break;

                    	default :
                    	    break loop8;
                        }
                    } while (true);

                    match("*)"); 

                    skip();

                    }
                    break;

            }
            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "COMMENT"

    public void mTokens() throws RecognitionException {
        // D:\\workspace\\TBT-front-end\\grammar\\TBTLexer.g:1:8: ( FORALL | ARROW | TLAMBDA | LAMBDA | DOT | SEMI | EQ | BIND | OR | DARROW | STAR | LETREC | LET | CASE | OF | IND | COIND | LPAREN | RPAREN | LCURLY | RCURLY | LANG | RANG | COLUMN | ID | TID | WS | COMMENT )
        int alt10=28;
        alt10 = dfa10.predict(input);
        switch (alt10) {
            case 1 :
                // D:\\workspace\\TBT-front-end\\grammar\\TBTLexer.g:1:10: FORALL
                {
                mFORALL(); 

                }
                break;
            case 2 :
                // D:\\workspace\\TBT-front-end\\grammar\\TBTLexer.g:1:17: ARROW
                {
                mARROW(); 

                }
                break;
            case 3 :
                // D:\\workspace\\TBT-front-end\\grammar\\TBTLexer.g:1:23: TLAMBDA
                {
                mTLAMBDA(); 

                }
                break;
            case 4 :
                // D:\\workspace\\TBT-front-end\\grammar\\TBTLexer.g:1:31: LAMBDA
                {
                mLAMBDA(); 

                }
                break;
            case 5 :
                // D:\\workspace\\TBT-front-end\\grammar\\TBTLexer.g:1:38: DOT
                {
                mDOT(); 

                }
                break;
            case 6 :
                // D:\\workspace\\TBT-front-end\\grammar\\TBTLexer.g:1:42: SEMI
                {
                mSEMI(); 

                }
                break;
            case 7 :
                // D:\\workspace\\TBT-front-end\\grammar\\TBTLexer.g:1:47: EQ
                {
                mEQ(); 

                }
                break;
            case 8 :
                // D:\\workspace\\TBT-front-end\\grammar\\TBTLexer.g:1:50: BIND
                {
                mBIND(); 

                }
                break;
            case 9 :
                // D:\\workspace\\TBT-front-end\\grammar\\TBTLexer.g:1:55: OR
                {
                mOR(); 

                }
                break;
            case 10 :
                // D:\\workspace\\TBT-front-end\\grammar\\TBTLexer.g:1:58: DARROW
                {
                mDARROW(); 

                }
                break;
            case 11 :
                // D:\\workspace\\TBT-front-end\\grammar\\TBTLexer.g:1:65: STAR
                {
                mSTAR(); 

                }
                break;
            case 12 :
                // D:\\workspace\\TBT-front-end\\grammar\\TBTLexer.g:1:70: LETREC
                {
                mLETREC(); 

                }
                break;
            case 13 :
                // D:\\workspace\\TBT-front-end\\grammar\\TBTLexer.g:1:77: LET
                {
                mLET(); 

                }
                break;
            case 14 :
                // D:\\workspace\\TBT-front-end\\grammar\\TBTLexer.g:1:81: CASE
                {
                mCASE(); 

                }
                break;
            case 15 :
                // D:\\workspace\\TBT-front-end\\grammar\\TBTLexer.g:1:86: OF
                {
                mOF(); 

                }
                break;
            case 16 :
                // D:\\workspace\\TBT-front-end\\grammar\\TBTLexer.g:1:89: IND
                {
                mIND(); 

                }
                break;
            case 17 :
                // D:\\workspace\\TBT-front-end\\grammar\\TBTLexer.g:1:93: COIND
                {
                mCOIND(); 

                }
                break;
            case 18 :
                // D:\\workspace\\TBT-front-end\\grammar\\TBTLexer.g:1:99: LPAREN
                {
                mLPAREN(); 

                }
                break;
            case 19 :
                // D:\\workspace\\TBT-front-end\\grammar\\TBTLexer.g:1:106: RPAREN
                {
                mRPAREN(); 

                }
                break;
            case 20 :
                // D:\\workspace\\TBT-front-end\\grammar\\TBTLexer.g:1:113: LCURLY
                {
                mLCURLY(); 

                }
                break;
            case 21 :
                // D:\\workspace\\TBT-front-end\\grammar\\TBTLexer.g:1:120: RCURLY
                {
                mRCURLY(); 

                }
                break;
            case 22 :
                // D:\\workspace\\TBT-front-end\\grammar\\TBTLexer.g:1:127: LANG
                {
                mLANG(); 

                }
                break;
            case 23 :
                // D:\\workspace\\TBT-front-end\\grammar\\TBTLexer.g:1:132: RANG
                {
                mRANG(); 

                }
                break;
            case 24 :
                // D:\\workspace\\TBT-front-end\\grammar\\TBTLexer.g:1:137: COLUMN
                {
                mCOLUMN(); 

                }
                break;
            case 25 :
                // D:\\workspace\\TBT-front-end\\grammar\\TBTLexer.g:1:144: ID
                {
                mID(); 

                }
                break;
            case 26 :
                // D:\\workspace\\TBT-front-end\\grammar\\TBTLexer.g:1:147: TID
                {
                mTID(); 

                }
                break;
            case 27 :
                // D:\\workspace\\TBT-front-end\\grammar\\TBTLexer.g:1:151: WS
                {
                mWS(); 

                }
                break;
            case 28 :
                // D:\\workspace\\TBT-front-end\\grammar\\TBTLexer.g:1:154: COMMENT
                {
                mCOMMENT(); 

                }
                break;

        }

    }


    protected DFA10 dfa10 = new DFA10(this);
    static final String DFA10_eotS =
        "\4\uffff\1\26\1\uffff\1\37\1\41\2\uffff\3\26\2\27\1\47\15\uffff"+
        "\1\51\4\uffff\2\26\1\54\2\27\3\uffff\1\60\1\26\1\uffff\2\27\1\26"+
        "\1\uffff\1\65\2\27\1\26\1\uffff\2\27\1\73\2\27\1\uffff\4\27\1\102"+
        "\1\27\1\uffff\1\27\1\105\1\uffff";
    static final String DFA10_eofS =
        "\106\uffff";
    static final String DFA10_minS =
        "\1\11\1\0\1\55\1\57\1\156\1\uffff\1\75\1\76\2\uffff\1\145\1\141"+
        "\1\146\1\156\1\157\1\52\15\uffff\1\60\4\uffff\1\164\1\163\1\60\1"+
        "\144\1\151\3\uffff\1\60\1\145\1\uffff\1\165\1\156\1\145\1\uffff"+
        "\1\60\1\143\1\144\1\143\1\uffff\1\164\1\165\1\60\1\151\1\143\1\uffff"+
        "\1\166\1\164\1\145\1\151\1\60\1\166\1\uffff\1\145\1\60\1\uffff";
    static final String DFA10_maxS =
        "\1\175\1\uffff\1\76\1\134\1\156\1\uffff\1\75\1\76\2\uffff\1\145"+
        "\1\141\1\146\1\156\1\157\1\52\15\uffff\1\172\4\uffff\1\164\1\163"+
        "\1\172\1\144\1\151\3\uffff\1\172\1\145\1\uffff\1\165\1\156\1\145"+
        "\1\uffff\1\172\1\143\1\144\1\143\1\uffff\1\164\1\165\1\172\1\151"+
        "\1\143\1\uffff\1\166\1\164\1\145\1\151\1\172\1\166\1\uffff\1\145"+
        "\1\172\1\uffff";
    static final String DFA10_acceptS =
        "\5\uffff\1\5\2\uffff\1\11\1\13\6\uffff\1\23\1\24\1\25\1\26\1\27"+
        "\1\30\1\31\1\32\1\33\1\34\1\1\1\2\1\3\1\uffff\1\10\1\6\1\12\1\7"+
        "\5\uffff\1\22\1\1\1\4\2\uffff\1\17\3\uffff\1\15\4\uffff\1\16\5\uffff"+
        "\1\14\6\uffff\1\20\2\uffff\1\21";
    static final String DFA10_specialS =
        "\1\uffff\1\0\104\uffff}>";
    static final String[] DFA10_transitionS = {
            "\2\30\2\uffff\1\30\22\uffff\1\30\2\uffff\1\31\4\uffff\1\17"+
            "\1\20\1\11\2\uffff\1\2\1\5\1\3\12\26\1\6\1\25\1\23\1\7\1\24"+
            "\2\uffff\2\27\1\16\5\27\1\15\21\27\1\uffff\1\1\4\uffff\2\26"+
            "\1\13\2\26\1\4\5\26\1\12\2\26\1\14\13\26\1\21\1\10\1\22",
            "\57\26\1\32\uffd0\26",
            "\1\31\20\uffff\1\33",
            "\1\31\54\uffff\1\34",
            "\1\35",
            "",
            "\1\36",
            "\1\40",
            "",
            "",
            "\1\42",
            "\1\43",
            "\1\44",
            "\1\45",
            "\1\46",
            "\1\31",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "\12\26\7\uffff\32\26\4\uffff\1\26\1\uffff\32\26",
            "",
            "",
            "",
            "",
            "\1\52",
            "\1\53",
            "\12\26\7\uffff\32\26\4\uffff\1\26\1\uffff\32\26",
            "\1\55",
            "\1\56",
            "",
            "",
            "",
            "\12\26\7\uffff\32\26\4\uffff\1\26\1\uffff\21\26\1\57\10\26",
            "\1\61",
            "",
            "\1\62",
            "\1\63",
            "\1\64",
            "",
            "\12\26\7\uffff\32\26\4\uffff\1\26\1\uffff\32\26",
            "\1\66",
            "\1\67",
            "\1\70",
            "",
            "\1\71",
            "\1\72",
            "\12\26\7\uffff\32\26\4\uffff\1\26\1\uffff\32\26",
            "\1\74",
            "\1\75",
            "",
            "\1\76",
            "\1\77",
            "\1\100",
            "\1\101",
            "\12\27\7\uffff\32\27\4\uffff\1\27\1\uffff\32\27",
            "\1\103",
            "",
            "\1\104",
            "\12\27\7\uffff\32\27\4\uffff\1\27\1\uffff\32\27",
            ""
    };

    static final short[] DFA10_eot = DFA.unpackEncodedString(DFA10_eotS);
    static final short[] DFA10_eof = DFA.unpackEncodedString(DFA10_eofS);
    static final char[] DFA10_min = DFA.unpackEncodedStringToUnsignedChars(DFA10_minS);
    static final char[] DFA10_max = DFA.unpackEncodedStringToUnsignedChars(DFA10_maxS);
    static final short[] DFA10_accept = DFA.unpackEncodedString(DFA10_acceptS);
    static final short[] DFA10_special = DFA.unpackEncodedString(DFA10_specialS);
    static final short[][] DFA10_transition;

    static {
        int numStates = DFA10_transitionS.length;
        DFA10_transition = new short[numStates][];
        for (int i=0; i<numStates; i++) {
            DFA10_transition[i] = DFA.unpackEncodedString(DFA10_transitionS[i]);
        }
    }

    class DFA10 extends DFA {

        public DFA10(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 10;
            this.eot = DFA10_eot;
            this.eof = DFA10_eof;
            this.min = DFA10_min;
            this.max = DFA10_max;
            this.accept = DFA10_accept;
            this.special = DFA10_special;
            this.transition = DFA10_transition;
        }
        public String getDescription() {
            return "1:1: Tokens : ( FORALL | ARROW | TLAMBDA | LAMBDA | DOT | SEMI | EQ | BIND | OR | DARROW | STAR | LETREC | LET | CASE | OF | IND | COIND | LPAREN | RPAREN | LCURLY | RCURLY | LANG | RANG | COLUMN | ID | TID | WS | COMMENT );";
        }
        public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
            IntStream input = _input;
        	int _s = s;
            switch ( s ) {
                    case 0 : 
                        int LA10_1 = input.LA(1);

                        s = -1;
                        if ( (LA10_1=='/') ) {s = 26;}

                        else if ( ((LA10_1>='\u0000' && LA10_1<='.')||(LA10_1>='0' && LA10_1<='\uFFFF')) ) {s = 22;}

                        if ( s>=0 ) return s;
                        break;
            }
            NoViableAltException nvae =
                new NoViableAltException(getDescription(), 10, _s, input);
            error(nvae);
            throw nvae;
        }
    }
 

}